home *** CD-ROM | disk | FTP | other *** search
/ Power CD-ROM!! 8 / Power CD-ROM 8.iso / prgmming / oldutil / adjram30.c < prev    next >
C/C++ Source or Header  |  1994-12-10  |  36KB  |  1,110 lines
  1. /*      Adjustable Ram Disk
  2.  
  3.  (c)    Copyright 1986 by Gary Cramblitt.  All Rights Reserved.
  4.  
  5.  v2.2    1 Jul 86   Initial version
  6.  v2.3   24 Aug 86   Bug.  FAT media byte not updated properly.
  7.  v2.4    29 Aug 86   If current drive is memory disk drive, reset current
  8.             directory on exit.
  9.  v2.5    30 Aug 86   Increase FAT to permit max size of 2043K;
  10.             Increase size of root directory to 128 entries;
  11.             Start code for /E option (Expanded Memory Support)
  12.  v3.0    30 Aug 86   Finish code for /E option.
  13.  
  14.     For program usage, see the last routine.
  15.  
  16.     This program is coded in DeSmet C v2.4.  Any function beginning
  17. with underscore (_) is a non-standard routine from the DeSmet library.
  18. They are:
  19.     _showcs()
  20.         Synopsis: unsigned _showcs()
  21.  
  22.         Returns the current value of CS.
  23.  
  24.     _showds()
  25.         Synopsis: unsigned _showds()
  26.  
  27.         Returns the current value of DS (= SS in DeSmet C).
  28.  
  29.     _peek()
  30.         Synopsis: char _peek(offset,segment)
  31.               char *offset;
  32.               unsigned segment;
  33.         Returns the byte at specified far address.
  34.  
  35.     _doint()
  36.         Synopsis: set any or all of the externs
  37.                   _rax,_rbx,_rcx,_rdx,_rsi,_rdi,_res,_rds
  38.         followed by
  39.               _doint(interrupt number);
  40.         Performs the specified interrupt with the specified
  41.         registers set from the externs.
  42.  
  43.         After the call, _rax, etc. can be used.  _carryf
  44.         and _zerof are extern char variables set to 1 if
  45.         the carry or zero flag is set.
  46.  
  47. In addition, the following routines are semi_standard, and may have
  48. slightly different implementations with your compiler:
  49.  
  50.     strncmp()
  51.         Synopsis: char *strncmp(leftstring,rightstring,max)
  52.                   char *leftstring, *rightstring
  53.               int max        
  54.         strncmp() compares up to a specified number of chars
  55.         in two strings.  It returns 0 if the specified number
  56.         of characters in the string are the same.
  57.  
  58.         free()
  59.         Synopsis: int free(pointer)
  60.               char *pointer
  61.         free memory previously allocated (by calloc).  Called
  62.         "cfree" in K&R.
  63. */
  64.  
  65. /* ==== Definitions ==== */
  66.  
  67. /* ---- Overall Definitions ---- */
  68.  
  69. #define true            1
  70. #define false            0
  71. #define max_size        2043    /* max memory disk size    */
  72.  
  73. /*
  74.    ---- To compile without LOTUS/INTEL/Microsoft Expanded Memory
  75.     support, change the "1" to "0" in the next statement.  This
  76.     will save about 2500 bytes in the .EXE file.
  77. */
  78.  
  79. #define em_support        1    /* compile for EM support */
  80.  
  81. /*
  82.     The following symbols must correspond to the same symbols in
  83.     file amdisk.asm.  If one is changed, so must the other.
  84.     This is because the first memory block may not be
  85.     deallocated.
  86. */
  87.  
  88. #define    min_size        64    /* minimum 64K = 128 sectors */
  89. #define    sec_per_blk        64    /* increment in 32K blocks */
  90.  
  91. /*
  92.    ---- Disk definitions.  Note: These constants should be made into
  93.     variables or functions if this program's algorithms need to
  94.     be generalized to disks of any type, especially high density disks.
  95.     Since this program works only in conjunction with amdisk.asm,
  96.     is OK to make them constants here.
  97. */
  98.  
  99. #define bytes_per_sec        512    /* 512 bytes per sector */
  100. #define par_per_sec        (512/16)
  101.                     /* 32 paragraphs per sector */
  102. #define sec_per_K        (1024/512)
  103.                     /* sectors per 1024 bytes */
  104. #define dir_per_sec        (512/sizeof(struct dir_entry))
  105.                     /* directory entries per sector */
  106. #define em_pag_per_blk        2    /* two 16K EM pages per mem block */
  107.  
  108. /* ---- Program Segment Prefix ---- */
  109.  
  110. #define    environment_segment    0x2c    /* segment address of the environment */
  111.  
  112. /* ---- DOS interrupts ---- */
  113.  
  114. #define    dosi_dosf        0x21    /* DOS function interrupt */
  115. #define    dosi_dsk_read        0x25    /* DOS absolute disk read interrupt */
  116. #define    dosi_dsk_write        0x26    /* DOS absolute disk write interrupt */
  117.  
  118. /* ---- User interrupts ---- */
  119.  
  120. #define usri_emm        0x67    /* LOTUS/INTEL/Microsoft Expanded
  121.                        Memory Manager */
  122. /* ---- DOS functions ---- */
  123.  
  124. #define dosf_seldisk        0x0e    /* set default disk */
  125. #define dosf_getdisk        0x19    /* get current default disk */
  126. #define dosf_getver        0x30    /* get DOS version number */
  127. #define    dosf_keepprc        0x31    /* keep process (term and stay resident) */
  128. #define dosf_drvfre        0x36    /* get disk free space */
  129. #define dosf_chdir        0x3b    /* set default directory */
  130. #define dosf_openh        0x3d    /* open file handle */
  131. #define dosf_closeh        0x3e    /* close file handle */
  132. #define dosf_ioctl        0x44    /* IOCTL */
  133. #define dosf_cwd        0x47    /* get current directory */
  134. #define dosf_alloc        0x48    /* allocate memory block */
  135. #define    dosf_dealloc        0x49    /* deallocate memory block */
  136. #define    dosf_setblk        0x4a    /* modify memory block */
  137.  
  138. /* ---- LOTUS/INTEL/Microsoft Expanded Memory Manager functions ---- */
  139.  
  140. #define emm_status        0x40    /* get manager status */
  141. #define emm_get_PFseg        0x41    /* get page frame segment */
  142. #define emm_get_pages        0x42    /* get number of pages */
  143. #define emm_get_handle        0x43    /* get handle and allocate memory */
  144. #define emm_map_memory        0x44    /* map memory */
  145. #define emm_fre_handle        0x45    /* free handle and memory */
  146. #define emm_get_ver        0x46    /* get EMM version */
  147. #define emm_sav_map        0x47    /* save mapping context */
  148. #define emm_res_map        0x48    /* restore mapping context */
  149. #define emm_num_handles        0x4b    /* get number of EMM handles */
  150. #define emm_hdl_pages        0x4c    /* get pages owned by handle */
  151. #define emm_all_pages        0x4d    /* get pages for all handles */
  152. #define emm_pag_map        0x4e    /* get or set page map */
  153.  
  154. #define nor_flg            0    /* memory block is in normal memory */
  155. #define em_flg            1    /* memory block is in expaned memory */
  156.  
  157. /*
  158.    ---- DOS Errors ----
  159.     These codes are returned by program and can be tested with DOS
  160.     IF statement.
  161. */
  162.  
  163. #define    dose_noerr        0    /* no error */
  164. #define dose_invfunc        1    /* invalid function */
  165. #define dose_arena        7    /* arena trashed */
  166. #define dose_noram        8    /* not enough memory */
  167. #define dose_invdrv        15    /* invalid drive */
  168.  
  169. /* ---- Directory definitions ---- */
  170.  
  171. #define never_used        0    /* directory entry never used */
  172. #define erased            0xe5    /* file has been erased */
  173. #define dir_bit            0x10    /* this bit indicates subdirectory */
  174.  
  175. /* ---- FAT definitions ---- */
  176.  
  177. #define available        0    /* cluster is available for use */
  178. #define bad            0xff7    /* cluster is bad */
  179. #define last_low        0xff8    /* last cluster for the file */
  180. #define last_high        0xfff    /* last cluster for the file */
  181.  
  182. extern unsigned _rax, _rbx, _rcx, _rdx, _rsi, _rdi, _res, _rds;
  183. extern char    _carryf, _zerof;
  184.  
  185. /* ---- Directory entry ---- */
  186.  
  187. struct dir_entry {
  188.   union dir_name {
  189.     char        name[8];
  190.     unsigned char    status;
  191.   } u_name;
  192.   char        ext[3];
  193.   unsigned char    attr;
  194.   unsigned char    reserved[10];
  195.   unsigned int    time;
  196.   unsigned int    date;
  197.   unsigned int    first_cluster;
  198.   unsigned long    size;
  199. };
  200.  
  201. /* ==== Global Data Storage ==== */
  202.  
  203. unsigned int pgm_seg;        /* CS at start of program saved here */
  204. int    drive_number;        /* memory disk drive number A=0, B=1, etc */
  205. int    mdisk_size;        /* user's desired memory disk size in K */
  206. int    mdisk_secs;        /* user's desired memory disk size in sectors */
  207. int    mdisk_chg;        /* the difference between disk's current size
  208.                    and the desired size (in sectors) */
  209. int    free_secs;        /* unused sectors in the memory disk */
  210. int    first_dir_sector;
  211. int    last_dir_sector;      /* loc of directory */
  212. int    first_fat_sector;
  213. int    last_fat_sector;    /* loc of FAT */
  214. int    free_cluster;        /* ptr to first free cluster */
  215. int    first_data_sector;    /* first sector after the last FAT */
  216.  
  217. /* ---- Memory Disk Boot Record ---- */
  218.  
  219. struct    boot_record {
  220.   unsigned char jmp[3];      /* non-bootable (no jump instruction ) */
  221.   char      ident[8];      /* identification */
  222.   unsigned int  bytes_in_sector;/* bytes/sector */
  223.   unsigned char sec_per_cluster;/* sectors/cluster */
  224.   unsigned int  bpb_reserved;      /* reserved sectors */
  225.   unsigned char bpb_fats;      /* number of FAT's */
  226.   unsigned int  bpb_root;      /* directory entries in root */
  227.   unsigned int  bpb_total;      /* total number of sectors */
  228.   unsigned char bpb_media;      /* media byte = number of mem blocks */
  229.   unsigned int  bpb_fat_size;      /* sectors/FAT */
  230.  
  231.   unsigned int  sec_per_track;    /* sectors/track */
  232.   unsigned int  heads;          /* number of heads */
  233.   unsigned int  hidden;          /* hidden sectors */
  234.  
  235.   struct mem_blk_table_entry {
  236.     unsigned char typ;          /* type of blk: 0 = normal 1 = EM */
  237.     unsigned int par;          /* paragraph address of block */
  238.     unsigned int siz;          /* number of sectors in the memory block */
  239.     unsigned int hdl;          /* expanded memory handle */
  240.   } mem_blk_table[max_size/sec_per_blk];
  241.   char    rest_of_record[bytes_per_sec - sizeof(struct boot_record)];
  242. } boot_sec;
  243.  
  244. /* ---- Memory disk default pathname ----- */
  245.  
  246.   struct pathname {
  247.     char drv;
  248.     char colon;
  249.     char slash;
  250.     char dir[64];
  251.   } mdisk_pathname; /* Ram disk's current pathname */
  252.  
  253. /* ---- Default drive ---- */
  254.  
  255.   unsigned char default_drive;
  256.  
  257. /* ---- Expanded Memory Manager ----- */
  258.  
  259.   unsigned int em_PFseg;    /* EMM's page frame segment */
  260.   int em_requested;        /* true if to expand using EM */
  261.   char em_device_name[] = "EMMXXXX0"; /* EMM device name */
  262.  
  263. /* ---- File Allocation Table ----*/
  264.  
  265.   unsigned char *fat;
  266.  
  267. /* ---- Declare types of library functions which return non-integer values */
  268.  
  269. char *calloc();        /* allocates memory for given number of things */
  270. char *strncmp();        /* comapares 2 strings of specified length */
  271. unsigned _showcs();    /* returns current CS register */
  272. char _peek();        /* returns a byte given segment and offset */
  273.  
  274. /* ==== MAIN ROUTINE ==== */
  275.  
  276. main(argc, argv)
  277.   int argc;
  278.   char *argv[];
  279.  
  280. {
  281.   int    err_code;        /* exit error code ( 0 if no error ) */
  282.   int    result;
  283.   int    j;
  284.   int    k;
  285.   int    m;
  286.  
  287.   /*
  288.      ---- Begin by saving the CS, which points to just after the 256-byte
  289.       PSP.  By subtracting 16, we get the segment pointer for the
  290.       program segment. This is, of course, highly DeSmet C dependent
  291.       code.  Hopefully, your compiler has some mechanism for getting
  292.       the program segment pointer.
  293.   */
  294.  
  295.   pgm_seg = _showcs() - 16;
  296.   printf("Adjust Memory Disk v3.0 ");
  297. #if em_support
  298.   printf("(with EM Support) ");
  299. #endif
  300.   printf(" (c) Copyright 1986 by Gary Cramblitt\n");
  301.   err_code = dose_noerr;  /* set no error */
  302.  
  303.   /* ---- Make sure MS-DOS 2 or above ---- */
  304.  
  305.   _rax = dosf_getver << 8;
  306.   _doint(dosi_dosf);
  307.   if (_rax & 0x00ff < 2) {
  308.     printf ("Error -- this program requires DOS version 2 or above.\n");
  309.     exit(dose_invfunc);
  310.   }
  311.  
  312.   /*
  313.      ---- Release our own environment block.  It doesn't hurt to do so.
  314.       Done so we don't have to do it in the future when user requests
  315.       memory disk shrinkage.
  316.   */
  317.  
  318.   _res = peekw(environment_segment, pgm_seg);
  319.   _rax = dosf_dealloc << 8;
  320.   _doint(dosi_dosf);  
  321.   if (_carryf == 1) {
  322.     printf("Error -- could not free environment block.  Error code %d\n",
  323.       _rax);
  324.     exit(dose_arena);
  325.   }
  326.  
  327.   /*
  328.      ---- Parse the command line drive letter.
  329.       If user makes an error, give him usage message and exit.
  330.   */
  331.  
  332.   if (argc < 2 || 
  333.     (drive_number = (toupper(*argv[1]) - 65)) < 0 || drive_number > 8) {
  334.     dsp_usage();
  335.     exit(dose_invfunc);
  336.   }
  337.  
  338.   /*
  339.      ---- Read the boot sector from the memory disk.  Verify that we are
  340.       dealing with the correct memory disk.
  341.   */
  342.  
  343.   if ((result = readsec(drive_number, 0, &boot_sec)) != 0) {
  344.     printf("Error -- could not read boot sector.  Error code %1d\n", result);
  345.     exit(dose_invdrv);
  346.   }
  347.   if (strcmp(boot_sec.ident,"AMDISK  ") != 0) {
  348.     printf("Error -- that drive is not the adjustable memory disk!\n");
  349.     exit(dose_invdrv);
  350.   }
  351.  
  352.   /* ---- Determine the drive's current size and free space. */
  353.  
  354.   mdisk_size = boot_sec.bpb_total/sec_per_K;
  355.   _rax = dosf_drvfre << 8;
  356.   _rdx = drive_number + 1;
  357.   _doint(dosi_dosf);
  358.   if (_rax == 0xffff) {
  359.     printf("Error -- Invalid drive letter or memory disk is not loaded.\n");
  360.     exit(dose_invdrv);
  361.   }
  362.   free_secs = _rbx * _rax;    /* avail clusters * sectors per cluster */
  363.   printf("Drive %c:    Total Size: %dK       Free Space: %dK\n",
  364.     drive_number + 65, mdisk_size, free_secs/sec_per_K);
  365.  
  366.   /*  ---- Obtain the default disk. ---- */
  367.  
  368.   _rax = dosf_getdisk << 8;
  369.   _doint(dosi_dosf);
  370.   default_drive = _rax & 0x00ff;
  371.   
  372.   /* ---- Get the memory disk's current directory. ---- */
  373.  
  374.   mdisk_pathname.drv = drive_number + 'A';
  375.   mdisk_pathname.colon = ':';
  376.   mdisk_pathname.slash = '\\';
  377.   _rax = dosf_cwd << 8;
  378.   _rdx = drive_number + 1;
  379.   _rds = _showds();
  380.   _rsi = mdisk_pathname.dir;
  381.   _doint(dosi_dosf);
  382.  
  383.   /*  ---- Allocate storage for the FAT and read it in.  ---- */
  384.  
  385.   fat = calloc(boot_sec.bpb_fat_size, bytes_per_sec);
  386.   first_fat_sector = boot_sec.bpb_reserved;
  387.   last_fat_sector = first_fat_sector + boot_sec.bpb_fat_size - 1;
  388.   k = 0;
  389.   for (j = first_fat_sector; j <= last_fat_sector; j++) {
  390.     readsec(drive_number, j, fat + k);
  391.     k = k + bytes_per_sec;
  392.   }
  393.  
  394.   /*
  395.      ---- Determine what user wants to do -- expand or shrink the memory
  396.       disk, and by how much.
  397.   */
  398.  
  399.   if (argc >= 3) {
  400.     if (toupper(*argv[2]) == 'F')
  401.       mdisk_chg = atoi(argv[2]+1) - free_secs/sec_per_K;
  402.     else if (toupper(*argv[2]) == 'M') {
  403.       mdisk_chg = atoi(argv[2]+1) - free_secs/sec_per_K;
  404.       if (mdisk_chg < 0) mdisk_chg = 0;
  405.     } else {
  406.       mdisk_chg = atoi(argv[2]);
  407.       if (*argv[2] == '+' || *argv[2] == '-'); else
  408.         mdisk_chg = mdisk_chg - (boot_sec.bpb_total/sec_per_K);
  409.     }
  410.   } else exit(dose_noerr);
  411.   mdisk_size = mdisk_chg + (boot_sec.bpb_total/sec_per_K);
  412.   mdisk_size = ((mdisk_size + (sec_per_blk/sec_per_K - 1))/
  413.     (sec_per_blk/sec_per_K))*(sec_per_blk/sec_per_K); /* round to 32K */
  414.   mdisk_secs = mdisk_size * sec_per_K;
  415.   mdisk_chg = mdisk_secs - boot_sec.bpb_total;
  416.   printf("          Desired Size: %dK   Desired Change: %dK\n",
  417.     mdisk_size, mdisk_chg/sec_per_K);
  418.   if (mdisk_size < min_size || mdisk_size > max_size) {
  419.     dsp_usage();
  420.     exit(dose_invfunc);
  421.   }
  422.  
  423.   /*
  424.      ---- If expanding into Expanded Memory, check to make sure that
  425.       EMM is available.  Check is made by opening the EMM device.
  426.       If open fails, EMM is not loaded.  Get page frame segment from
  427.       EMM.  Raw DOS handle open is used here to avoid bringing in
  428.       huge DeSmet IO routines.
  429.   */
  430.  
  431.   em_requested = false;
  432. #if em_support
  433.   if (argc == 4 && toupper(*(argv[3]+1)) == 'E') {
  434.     _rax = (dosf_openh << 8) + 0;    /* open a handle function */
  435.     _rds = _showds();
  436.     _rdx = &em_device_name;        /* DS:DX => "EMMXXXX0" */
  437.     _doint(dosi_dosf);
  438.     j = _rax;                /* j = returned handle */
  439.     if (_carryf == 1) {
  440.       printf("Error -- Expanded Memory Manager is not available.\n");
  441.       printf("         Error code: %d\n",_rax);
  442.       exit(dose_invfunc);
  443.     } else {
  444.       _rax = (dosf_ioctl << 8) + 7;    /* Get output status */
  445.       _rbx = j;                /* BX = handle */
  446.       _doint(dosi_dosf);
  447.       _rbx = j;                /* BX = handle */
  448.       j = _rax & 0xff;            /* j = returned device status */
  449.       _rax = dosf_closeh << 8;        /* close handle */
  450.       _doint(dosi_dosf);
  451.       if (j == 0xff) {
  452.         em_requested = true;        /* flag EM requested */
  453.         _rax = emm_get_PFseg << 8;    /* get EM page frame segment */
  454.         _doint(usri_emm);
  455.         _rax = _rax >> 8;        /* status in AH */
  456.         if (_rax == 0) em_PFseg = _rbx;
  457.         else {
  458.           printf("Error -- Expanded Memory Manager could not report page frame.\n");
  459.           printf("         Error code: %2xH\n",_rax);
  460.           exit(dose_noram);
  461.         }
  462.       } else {
  463.         printf("Error -- Expanded Memory Manager is not available.\n");
  464.         printf("         Error code: %2xH\n",j);
  465.         exit(dose_invfunc);
  466.       }
  467.     }
  468.   }
  469. #endif
  470.  
  471.   /*
  472.      ---- Expand or shrink as indicated.  If shrinking, first make
  473.       sure there is sufficient room.
  474.   */
  475.  
  476.   if (mdisk_chg < 0 ) {
  477.     if (free_secs > -mdisk_chg) err_code = shrink();
  478.     else {
  479.       printf("Error -- NOT enough room to do the shrink.\n");
  480.       printf("         You must first erase some files.\n");
  481.       dsp_mem_blk_table();
  482.       exit(dose_noerr);
  483.     }
  484.   } else if (mdisk_chg > 0) err_code = expand();
  485.   else printf ("The disk is already that size!  Nothing to do.\n");
  486.  
  487.   /* ---- Write the new FAT back to disk */
  488.  
  489.   if (err_code == dose_noerr)
  490.     for (m = 0; m < boot_sec.bpb_fats; m++) {
  491.       k = 0;
  492.       for (j = first_fat_sector; j <= last_fat_sector; j++) {
  493.         writesec(drive_number, j, fat + k);
  494.         k = k + bytes_per_sec;
  495.       }
  496.       first_fat_sector = first_fat_sector + boot_sec.bpb_fat_size;
  497.       last_fat_sector = last_fat_sector + boot_sec.bpb_fat_size;
  498.     }
  499.  
  500.   /* ---- Write the updated boot sector back to memory disk ---- */
  501.  
  502.   if (err_code == dose_noerr)
  503.     if ((result = writesec(drive_number, 0, &boot_sec)) != 0) {
  504.       printf("Error -- could not write boot sector back.  Code: %1d\n", result);
  505.       printf("Reboot recommended.\n");
  506.       err_code = dose_invdrv;
  507.     }
  508.  
  509.   /*
  510.    ---- Restore the memory disk's default directory, then reset default
  511.     drive.
  512.   */
  513.  
  514.   if (err_code == dose_noerr) {
  515.     _rax = dosf_chdir << 8;
  516.     _rds = _showds();
  517.     _rdx = &mdisk_pathname;
  518.     _doint(dosi_dosf);
  519.  
  520.     _rax = dosf_seldisk << 8;
  521.     _rdx = default_drive;
  522.     _doint(dosi_dosf);
  523.   }
  524.  
  525.   /* ---- Free the C-allocated variables. ---- */
  526.  
  527.   free(fat);
  528.  
  529.   /* ---- Display Memory Block Table ----- */
  530.  
  531.   dsp_mem_blk_table();
  532.  
  533.   /*
  534.      ---- If expanding and EM was not requested, terminate normally by
  535.       using terminate and stay resident function.
  536.   */
  537.  
  538.   if (err_code == dose_noerr && !em_requested && mdisk_chg > 0) {
  539.     _rax = (dosf_keepprc << 8) + dose_noerr;
  540.     _rdx = sec_per_blk * par_per_sec;
  541.     _doint(dosi_dosf);            /* PROGRAM TERMINATES HERE */
  542.   }
  543.  
  544.   exit(err_code);
  545.  
  546. } /* End of main routine */
  547.  
  548. /* ==== EXPAND ROUTINE ==== */
  549. /*      Expands the memory disk by allocating new memory blocks to it. */
  550.  
  551. int expand()
  552. {
  553.   int    result, j;
  554.   int    mdisk_dif;
  555.  
  556.   /*
  557.      ---- Size the already existing main memory block to 32K.
  558.       We do this twice, once now, and once when we exit and
  559.       stay resident.  We do it now so as to detect any possible errors.
  560.       The real allocation will be done at termination time.
  561.   */
  562.  
  563.   mdisk_dif = mdisk_chg;
  564.   if (!em_requested) {
  565.     printf("Alocating new %dK memory block #%d\n",
  566.       sec_per_blk/sec_per_K, boot_sec.bpb_media);
  567.     _rax = dosf_setblk << 8;
  568.     _res = pgm_seg;
  569.     _rbx = sec_per_blk * par_per_sec;
  570.     _doint(dosi_dosf);
  571.     if (_carryf == 1) {
  572.       printf("Error -- could not modify memory block size.  Error code %1d\n",
  573.         _rax);
  574.       printf("Probably caused by not enough free memory.\n");
  575.       return(dose_noram);
  576.     }
  577.     mdisk_dif = mdisk_dif - sec_per_blk;
  578.  
  579.     /*
  580.        Increment the media byte to show an additional memory block has been
  581.        allocated.  Set the starting paragraph and size (in sectors) for the
  582.        new block in the memory block table.
  583.     */
  584.  
  585.     boot_sec.mem_blk_table[boot_sec.bpb_media].typ = nor_flg;
  586.     boot_sec.mem_blk_table[boot_sec.bpb_media].par = pgm_seg;
  587.     boot_sec.mem_blk_table[boot_sec.bpb_media].siz = sec_per_blk;
  588.     boot_sec.mem_blk_table[boot_sec.bpb_media].hdl = 0;
  589.  
  590.     boot_sec.bpb_media = boot_sec.bpb_media + 1;
  591.     fatput(boot_sec.bpb_media, 0, fat);  
  592.  
  593.     /* Increase the total number of sectors. */
  594.  
  595.     boot_sec.bpb_total = boot_sec.bpb_total + sec_per_blk;
  596.   }
  597.  
  598.   /* Now allocate new memory blocks for the remaining desired space. */
  599.  
  600.   for (;mdisk_dif > 0; mdisk_dif = mdisk_dif - sec_per_blk) {
  601.     printf("Allocating new %dK memory block #%d\n",
  602.       sec_per_blk/sec_per_K,boot_sec.bpb_media);
  603. #if em_support
  604.     if (em_requested) {
  605.       _rax = emm_get_handle << 8;
  606.       _rbx = em_pag_per_blk;
  607.       _doint(usri_emm);
  608.       _rax = _rax >> 8;
  609.       if (_rax == 0) {
  610.         boot_sec.mem_blk_table[boot_sec.bpb_media].typ = em_flg;
  611.         boot_sec.mem_blk_table[boot_sec.bpb_media].par = em_PFseg;
  612.         boot_sec.mem_blk_table[boot_sec.bpb_media].siz = sec_per_blk;
  613.         boot_sec.mem_blk_table[boot_sec.bpb_media].hdl = _rdx;
  614.         boot_sec.bpb_total = boot_sec.bpb_total + sec_per_blk;
  615.         boot_sec.bpb_media = boot_sec.bpb_media + 1;
  616.         fatput(boot_sec.bpb_media, 0, fat);
  617.       } else {
  618.         printf("Error -- could not allocate new memory block from EMM.");
  619.     printf("  Error code %2x\n",_rax);
  620.         printf("Probably caused by not enough free memory.\n");
  621.         break;
  622.       }
  623.     } else
  624. #endif
  625.     {
  626.       _rax = dosf_alloc << 8;
  627.       _rbx = sec_per_blk * par_per_sec;
  628.       _doint(dosi_dosf);
  629.       if (_carryf == 1) {
  630.         printf("Error -- could not allocate new memory block.  Error code %1d\n",
  631.           _rax);
  632.         printf("Probably caused by not enough free memory.\n");
  633.         break;
  634.       } else {
  635.         boot_sec.mem_blk_table[boot_sec.bpb_media].typ = nor_flg;
  636.         boot_sec.mem_blk_table[boot_sec.bpb_media].par = _rax;
  637.         boot_sec.mem_blk_table[boot_sec.bpb_media].siz = sec_per_blk;
  638.         boot_sec.mem_blk_table[boot_sec.bpb_media].hdl = 0;
  639.         boot_sec.bpb_total = boot_sec.bpb_total + sec_per_blk;
  640.         boot_sec.bpb_media = boot_sec.bpb_media + 1;
  641.         fatput(boot_sec.bpb_media, 0, fat);
  642.       }
  643.     }
  644.   }
  645.   return(dose_noerr);
  646.  
  647. } /* end of expand routine */
  648.  
  649. /*
  650.    ==== SHRINK ROUTINE ====
  651.     Shrinks the memory disk by moving all file sectors down
  652.     to lowest possible locations, then deallocating memory
  653.     blocks.
  654. */
  655.  
  656. int shrink()
  657. {
  658.  
  659. /* ==== Data Storage ==== */
  660.  
  661. /* ---- Root Directory ---- */
  662.  
  663.   struct dir_entry root_dir[dir_per_sec];
  664.  
  665. /* ---- Other locals ---- */
  666.  
  667.   int cur_dir;                  /* ptr to current directory */
  668.   int dir_sector;              /* current directory sector */
  669.   int mdisk_dif;              /* desired change in sectors */
  670.   char tmpstr[20];
  671.   int j, result;
  672.  
  673.   mdisk_dif = -mdisk_chg;    /* make variable positive */
  674.  
  675.   result = dose_noerr;
  676.  
  677.   /* ---- Calculate the location of the directory sectors. */
  678.  
  679.   first_dir_sector = boot_sec.bpb_reserved + 
  680.     (boot_sec.bpb_fat_size * boot_sec.bpb_fats);
  681.   last_dir_sector = (boot_sec.bpb_root * sizeof(struct dir_entry) /
  682.     bytes_per_sec) + first_dir_sector - 1;
  683.  
  684.   /* ---- First data sector follows the last root directory sector. */
  685.  
  686.   first_data_sector = last_dir_sector + 1;
  687.  
  688.   /*
  689.      ---- Locate the first available cluster in the FAT. First FAT entry
  690.       is number 2, not 0, because the first two FAT entries are used
  691.       for the media descriptor and filler.
  692.   */
  693.  
  694.   for (free_cluster = 2; fatget(free_cluster, fat) != available;
  695.     free_cluster++);
  696.  
  697.   /*
  698.      ---- Loop through the root directory, packing the clusters of
  699.       each file to the lowest possible locations.
  700.   */
  701.  
  702.   for (dir_sector = first_dir_sector; dir_sector <= last_dir_sector;
  703.     dir_sector++)
  704.   {
  705.     readsec(drive_number, dir_sector, &root_dir);
  706.     for (cur_dir = 0; cur_dir < dir_per_sec; cur_dir++)
  707.       if ((result = pack_file(&(root_dir[cur_dir]), 0, fat)) != dose_noerr)
  708.         break;
  709.     writesec(drive_number, dir_sector, &root_dir);
  710.     if (result != dose_noerr) break;
  711.   }
  712.  
  713.   /*
  714.       ---- Free up memory.  Loop backwards through the memory block table,
  715.        freeing allocated memory blocks.  As we do so, decrement the
  716.        media byte (memory block counter) and total sectors.
  717.   */
  718.  
  719.   j = boot_sec.bpb_media - 1;
  720.   if (result == dose_noerr) while (mdisk_dif >= sec_per_blk) {
  721.     if (mdisk_dif >= boot_sec.mem_blk_table[j].siz) {
  722.       printf("Freeing memory block #%d\n",j);
  723.       if (boot_sec.mem_blk_table[j].typ == nor_flg) {
  724.         _res = boot_sec.mem_blk_table[j].par;
  725.         _rax = dosf_dealloc << 8;
  726.         _doint(dosi_dosf);
  727.         if (_carryf == 1) {
  728.           printf ("Error -- could not free allocated memory block #%d.",j);
  729.           printf ("  Error code %d\n",_rax);
  730.         }
  731.       }
  732. #if em_support
  733.       else {
  734.         _rax = emm_fre_handle << 8;
  735.     _rdx = boot_sec.mem_blk_table[j].hdl;
  736.     _doint(usri_emm);
  737.     _rax = _rax >> 8;
  738.     if (_rax != 0) {
  739.           printf ("Error -- could not free EM pages for memory block #%d.",j);
  740.           printf ("  Error code %2x\n",_rax);
  741.         }
  742.       }
  743. #endif
  744.       boot_sec.bpb_media = boot_sec.bpb_media - 1;
  745.       fatput(boot_sec.bpb_media, 0, fat);
  746.       boot_sec.bpb_total = boot_sec.bpb_total - 
  747.         boot_sec.mem_blk_table[j].siz;
  748.       mdisk_dif = mdisk_dif - boot_sec.mem_blk_table[j].siz;
  749.     }
  750.   j = j - 1;
  751.   }
  752.  
  753.   return(result);
  754.  
  755. } /* end of shrink routine */
  756.  
  757. /*
  758.    ==== PACK_FILE ROUTINE ====
  759.     Given the directory entry for a file, packs all the clusters
  760.     for that file to the lowest possible locations.  If the file
  761.     is itself a subdirectory, then this routine will be called
  762.     recursively via the "move_cluster" routine, i.e., "pack_file
  763.     calls "move_cluster" who calls "pack_file" who calls
  764.     "move_cluster" who calls "pack_file", etc.
  765.  
  766.     Clusters are packed down by moving any cluster above
  767.     "free_cluster" down to "free_cluster".  Then the next free
  768.     cluster is located and the next cluster is examined.
  769. */
  770.  
  771. int pack_file(dir, parent_cluster, fat)
  772.   struct dir_entry *dir;
  773.   int parent_cluster;
  774.   unsigned char fat[];
  775. {
  776.   int next_cluster;
  777.   int cur_cluster;
  778.   int new_cluster;
  779.   int result;
  780.  
  781.   /* Is this directory entry erased or never used?  If so, do nothing. */
  782.  
  783.   result = dose_noerr;
  784.   if (dir->u_name.status != never_used && 
  785.     dir->u_name.status != erased) {
  786.  
  787.     /* 
  788.     If file is not 0 length or it is a subdirectory file,
  789.         we can pack it.
  790.     */
  791.  
  792.     if (dir->size > 0 || isdir(dir)) {
  793.  
  794.       /* 
  795.       Handle the first cluster number, which is stored in the
  796.           directory entry, not in the FAT.
  797.       */
  798.  
  799.       next_cluster = dir->first_cluster;
  800.       if (next_cluster > free_cluster) {
  801.         new_cluster = free_cluster;
  802.         fatput(fatget(next_cluster, fat), new_cluster, fat);
  803.         dir->first_cluster = new_cluster;
  804.         fatput(available, next_cluster, fat);
  805.         for (; fatget(free_cluster, fat) != available; free_cluster++);
  806.         result = move_cluster(dir, parent_cluster, fat,
  807.           drive_number, next_cluster, new_cluster);
  808.       }
  809.  
  810.       /* Handle rest of clusters stored in the FAT */
  811.  
  812.       if (result == dose_noerr) for (cur_cluster = dir->first_cluster;
  813.         !islast(next_cluster = fatget(cur_cluster, fat));
  814.         cur_cluster = fatget(cur_cluster, fat)) {
  815.         if (next_cluster > free_cluster) {
  816.           new_cluster = free_cluster;
  817.           fatput(fatget(next_cluster, fat), new_cluster, fat);
  818.           fatput(new_cluster, cur_cluster, fat);
  819.           fatput(available, next_cluster, fat);
  820.           for (; fatget(free_cluster, fat) != available; free_cluster++);
  821.           result = move_cluster(dir, parent_cluster, fat,
  822.             drive_number, next_cluster, new_cluster);
  823.           if (result != dose_noerr) break;
  824.         }
  825.       }
  826.     }
  827.   }
  828.   return(result);
  829. }
  830.  
  831. /*
  832.    ==== MOVE_CLUSTER ROUTINE ====
  833.     Moves all sectors of secified cluster. If the file whose clusters
  834.     are being moved is a subdirectory, then call "pack_file" routine
  835.     recursively.
  836. */
  837.  
  838. int move_cluster (dir, parent_cluster, fat, drive, from, to)
  839.   struct dir_entry *dir;
  840.   int parent_cluster;
  841.   unsigned char fat[];
  842.   int drive, from, to;
  843. {
  844.   struct dir_entry a_sector[dir_per_sec];
  845.   int cur_dir;
  846.   int result;
  847.   char *tryit;
  848.   int j;
  849.  
  850.   result = dose_noerr;
  851.   from = (from-2) * boot_sec.sec_per_cluster + first_data_sector;
  852.   to = (to-2) * boot_sec.sec_per_cluster + first_data_sector;
  853.   for (j = 0; j < boot_sec.sec_per_cluster; j++) {
  854.     readsec(drive_number, from + j, &a_sector);
  855.  
  856.     /*
  857.     If this sector belongs to a directory file, then we must
  858.     recursively call the pack_file routine. The first two entries
  859.     in any subdirectory, however, are special.  They are named
  860.     "." and ".."  The first points to the disk location of the
  861.     beginning of this subdirectory; the second to the disk location
  862.     of the parent directory (0 if root directory)
  863.     */
  864.  
  865.     if (isdir(dir))
  866.       for (cur_dir = 0; cur_dir < dir_per_sec; cur_dir++) {
  867.         if (a_sector[cur_dir].u_name.name[0] == '.') {
  868.           if (a_sector[cur_dir].u_name.name[1] == '.')
  869.             a_sector[cur_dir].first_cluster = parent_cluster;
  870.           else a_sector[cur_dir].first_cluster = dir->first_cluster;
  871.         }
  872.         else {
  873.           /* In DeSmet C, local variables are allocated on the stack. */
  874.       /* Make sure there is sufficient stack space for the recursive */
  875.           /* call.  If not, display message, return error code, and */
  876.           /* calling routines will attempt a graceful exit. Test if */
  877.           /* stack has enough room by allocating space from it, then */
  878.           /* freeing it. */
  879.           if ((tryit = calloc(700, 1)) != 0) {
  880.             free(tryit);
  881.             pack_file(&(a_sector[cur_dir]), dir->first_cluster, fat);
  882.           } else {
  883.             printf("Error -- Insufficient stack space to pack ");
  884.             printf("subdirectory %s\n", a_sector[cur_dir].u_name.name);
  885.             printf("Too many subdirectories.  Shrink abandoned. ");
  886.         printf("Reboot recommended.\n");
  887.             result = dose_noram;
  888.             /* Note: Even though we can't handle the subdirectory, */
  889.         /* keep going anyway so as to maintain integrity of disk. */
  890.           }
  891.         }
  892.       }
  893.       
  894.     writesec(drive_number, to + j, &a_sector);
  895.   }
  896.   return(result);
  897. }
  898.  
  899. /*
  900.    ==== ISDIR ROUTINE ====
  901.     Given a directory entry, returns true if the entry is for a
  902.     subdirectory file.
  903. */
  904.  
  905. int isdir(dir)
  906.   struct dir_entry *dir;
  907. {
  908.   if (dir->attr & dir_bit) return(true); else return(false);
  909. }
  910.  
  911. /*
  912.    ==== ISLAST ROUTINE ====
  913.     Given a FAT entry, returns true if it is an EOF marker.
  914. */
  915.  
  916. int islast(cluster)
  917.   int cluster;
  918. {
  919.   int j;
  920.   int result;
  921.  
  922.   result = false;
  923.   for (j = last_low; j <= last_high; j++)
  924.     if (cluster == j) result = true;
  925.   return(result);
  926. }
  927.  
  928. /*
  929.    ==== FATGET ROUTINE ====
  930.     Given cluster number and FAT, returns the 12-bit FAT entry in
  931.     and integer word, right-adjusted.
  932. */
  933.  
  934. int fatget (cluster, fat)
  935.   int cluster;
  936.   unsigned char fat[];
  937. {
  938.   int clloc, clword;
  939.  
  940.   clloc = 3*cluster/2;
  941.   clword = fat[clloc] + (fat[clloc+1] << 8);
  942.   if (cluster & 1) return (clword >> 4); else return (clword & 0x0fff);
  943. }
  944.  
  945. /*
  946.    ==== FATPUT ROUTINE ====
  947.     Given a 12-bit FAT entry, cluster number, and the FAT, stores
  948.     the entry into the FAT.
  949. */
  950.  
  951. int fatput (wd12bits, cluster, fat)
  952.   int cluster;
  953.   int wd12bits;
  954.   unsigned char fat[];
  955. {
  956.   int clloc, clword;
  957.  
  958.   clloc = 3*cluster/2;
  959.   clword = fat[clloc] + (fat[clloc+1] << 8);
  960.   if (cluster & 1)
  961.     clword = (clword & 0x000f) | (wd12bits << 4);
  962.   else
  963.     clword = (clword & 0xf000) | wd12bits;
  964.   fat[clloc] = clword & 0x00ff;
  965.   fat[clloc+1] = clword >> 8;
  966. }
  967.  
  968. /*
  969.    ==== DSP_MEM_BLK_TABLE ROUTINE ====
  970.     Displays the Memory Block Table on the screen.
  971. */
  972.  
  973. dsp_mem_blk_table()
  974. {
  975.   int j;
  976.  
  977. #if em_support
  978.   printf("\n");
  979.   printf("              Memory Block Table\n");
  980.   printf("Block #   Paragraph    Size(sectors)    EM Handle\n");
  981.   printf("-------   ---------    -------------    ---------\n");
  982.   for (j = 0; j < boot_sec.bpb_media; ++j) {
  983.   printf("  %1d         %4x           %3d          ",
  984.       j,boot_sec.mem_blk_table[j].par,boot_sec.mem_blk_table[j].siz);
  985.     if (boot_sec.mem_blk_table[j].typ == em_flg) 
  986.       printf("  %4x",boot_sec.mem_blk_table[j].hdl);
  987.     else printf("  --");
  988.     printf("\n");
  989.   }
  990. #else
  991.   printf("\n");
  992.   printf("         Memory Block Table\n");
  993.   printf("Block #   Paragraph    Size(sectors)\n");
  994.   printf("-------   ---------    -------------\n");
  995.   for (j = 0; j < boot_sec.bpb_media; ++j) {
  996.   printf("  %1d         %4x           %3d\n",
  997.       j,boot_sec.mem_blk_table[j].par,boot_sec.mem_blk_table[j].siz);
  998.   }
  999. #endif
  1000.  
  1001. }
  1002.  
  1003. /*
  1004.    ==== PEEKW ROUTINE ====
  1005.     Given segment and offset, returns the word thereby addressed.
  1006.     Written because DeSmet C uses small memory model and there are
  1007.     no FAR data types.
  1008. */
  1009.  
  1010. int peekw(off, seg)
  1011.   unsigned char *off;
  1012.   int seg;
  1013. {
  1014.   return((_peek(off+1, seg) << 8) + _peek(off, seg));
  1015. }
  1016.  
  1017. /*
  1018.    ==== READSEC ====
  1019.     Given drive number, desired logical sector number, and a sector
  1020.     buffer, this routine reads the sector into the buffer.
  1021.  
  1022.   NOTE: This routine uses DeSmet's "_doint" routine to perform absolute
  1023.     disk read interrupt number 25H.  This interrupt, unlike most
  1024.     interrupts, leaves the flags register on the stack when it returns.
  1025.     In DeSmet this is OK, because the called routine restores the
  1026.     stack frame prior to RETurning.  In some C compilers, this scheme
  1027.     won't work.  For example, in AZTEC C, it is the CALLING routine's
  1028.     responsibility to restore the stack frame.  In AZTEC, then, we
  1029.     would RETurn to the wrong address and die.  So look out, if you are
  1030.     converting this program to some other version of C.
  1031. */
  1032.  
  1033. readsec (drive, sector, buffer)
  1034.   int drive;
  1035.   int sector;
  1036.   char *buffer;
  1037. {
  1038.   _rax = drive;
  1039.   _rds = _showds();  /* ASSUMPTION: DS = SS in DeSmet C */
  1040.   _rbx = buffer;
  1041.   _rcx = 1;
  1042.   _rdx = sector;
  1043.   _doint(dosi_dsk_read);
  1044.   if (_carryf == 1) return (_rax); else return (0);
  1045. }
  1046.  
  1047. /*
  1048.    ==== WRITESEC ROUTINE ====
  1049.     Given drive number, logical sector number, and a buffer, this
  1050.     routine writes the sector to disk.
  1051.  
  1052.     See the note under routine READSEC.
  1053. */
  1054.  
  1055. writesec (drive, sector, buffer)
  1056.   int drive;
  1057.   int sector;
  1058.   char *buffer;
  1059. {
  1060.   _rax = drive;
  1061.   _rds = _showds();    /* ASSUMPTION: DS = SS in DeSmet C */
  1062.   _rbx = buffer;
  1063.   _rcx = 1;
  1064.   _rdx = sector;
  1065.   _doint(dosi_dsk_write);
  1066.   if (_carryf == 1) return (_rax); else return (0);
  1067. }
  1068.  
  1069. /*
  1070.    ==== DSP_USAGE ROUTINE ====
  1071.     Displays message how to use program.
  1072. */
  1073.  
  1074. int dsp_usage()
  1075.  
  1076. {
  1077. #if em_support
  1078.  printf("Usage:\n  ADJRAM drive size option\nWhere:\n");
  1079. #else
  1080.  printf("Usage:\n  ADJRAM drive size\nWhere:\n");
  1081. #endif
  1082.  printf("  drive = memory disk drive letter, A to I\n");
  1083.  printf("  size  = size of memory disk in K, %d to %d, in following format:\n",
  1084.    min_size,max_size);
  1085.  printf("            xxx   = set memory disk size to xxx\n");
  1086.  printf("            +xxx  = increase memory disk size by xxx\n");
  1087.  printf("            -xxx  = decrease memory disk size by xxx\n");
  1088.  printf("            Fxxx  = adjust size so there is xxx free space\n");
  1089.  printf("            Mxxx  = ensure there is at least xxx of free space\n");
  1090.  printf("          Size will be rounded to the next highest %dK\n",
  1091.    sec_per_blk/sec_per_K);
  1092.  printf("          If size is omitted, current drive size is displayed.\n");
  1093. #if em_support
  1094.  printf("  option= optional /E if INTEL/LOTUS/Microsoft Expanded Memory\n");
  1095.  printf("          is to be used for any expansion\n");
  1096. #endif
  1097.  printf("Examples:\n");
  1098.  printf("  ADJRAM C: 250\n");
  1099.  printf("          will set memory disk C to 256K\n");
  1100. #if em_support
  1101.  printf("  ADJRAM i: +60 /E\n");
  1102.  printf("          will increase memory disk I by 64K, using expanded memory\n");
  1103. #else
  1104.  printf("  ADJRAM i: +60\n");
  1105.  printf("          will increase memory disk I by 64K\n");
  1106. #endif
  1107.  printf("  ADJRAM C: m64\n");
  1108.  printf("          will ensure there is at least 64K free space on drive C\n");
  1109. }
  1110.